home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / demo / wemdemo4.zip / INFO / EDEBUG.2 (.txt) < prev    next >
GNU Info File  |  1994-09-21  |  22KB  |  390 lines
  1. This is Info file ../info/edebug, produced by Makeinfo-1.56 from the
  2. input file edebug.txi.
  3.    This file documents Edebug
  4.    This is edition 1.2 of the Edebug User Manual for edebug Version 2.6,
  5.    Copyright (C) 1991 Daniel LaLiberte
  6.    Permission is granted to make and distribute verbatim copies of this
  7. manual provided the copyright notice and this permission notice are
  8. preserved on all copies.
  9.    Permission is granted to copy and distribute modified versions of
  10. this manual under the conditions for verbatim copying, provided that
  11. the entire resulting derived work is distributed under the terms of a
  12. permission notice identical to this one.
  13.    Permission is granted to copy and distribute translations of this
  14. manual into another language, under the above conditions for modified
  15. versions, except that this permission notice may be stated in a
  16. translation approved by the Foundation.
  17. File: edebug,  Node: Options,  Next: Todo List,  Prev: Macro Calls,  Up: Top
  18. Options
  19. =======
  20.  - User Option: edebug-all-defuns
  21.      Default `nil'.  If non-`nil', all `defuns' and `defmacros'
  22.      evaluated will use edebug.  `eval-defun' without prefix arg and
  23.      `eval-region' will use `edebug-defun'.
  24.      If `nil', `eval-region' evaluates normally, but `eval-defun' with
  25.      prefix arg uses `edebug-defun'.  `eval-region' is called by
  26.      `eval-defun', `eval-last-sexp', and `eval-print-last-sexp'.
  27.      You may wish to make this variable local to each elisp buffer by
  28.      calling `(make-local-variable 'edebug-all-defuns)' in your
  29.      `emacs-lisp-mode-hook'.  You can use the function
  30.      `edebug-all-defuns' to toggle its value.
  31.  - User Option: edebug-eval-macro-args
  32.      Default `nil'.  If non-`nil', edebug will assume that all macro
  33.      call arguments for macros that have no `edebug-form-spec' may be
  34.      evaluated, otherwise it will not.  To specify exceptions for macros
  35.      that have some arguments evaluated and some not, you should
  36.      specify an `edebug-form-spec' (*note Macro Calls::.).
  37.  - User Option: edebug-stop-before-symbols
  38.      Default `nil'.  Non-`nil' causes edebug to stop before symbols as
  39.      well as after.  This option is used when the `edebug-defun' is
  40.      called, not when edebugging, so set the option before using
  41.      `edebug-defun'.
  42.  - User Option: edebug-save-windows
  43.      Default `t'.  If non-`nil', save and restore window configuration
  44.      on edebug calls.  It takes some time to save and restore, so if
  45.      your program does not care what happens to the window
  46.      configurations, it is better to set this variable to `nil'.
  47.  - User Option: edebug-save-point
  48.      Default `t'.  If non-`nil', save and restore the point and mark in
  49.      source code buffers.
  50.  - User Option: edebug-save-displayed-buffer-points
  51.      Default `nil'.  If non-`nil', save and restore the points of all
  52.      buffers, displayed or not.
  53.      Saving and restoring buffer points is necessary if you are
  54.      debugging code that changes the point of a buffer which is
  55.      displayed in a non-selected window.  If edebug or the user then
  56.      selects the window, the buffer's point will be changed to the
  57.      window's point.
  58.      Saving and restoring is an expensive operation since it visits each
  59.      window and each displayed buffer twice for each edebug call, so it
  60.      is best to avoid it if you can.
  61.  - User Option: edebug-initial-mode
  62.      Default `'step'.  Global initial mode for edebug, if non-`nil'.
  63.      This is used when edebug is first entered for each recursive-edit
  64.      level.  Possible values are `nil' (meaning use the current
  65.      edebug-mode), `'step', `'go', `'Go-nonstop', `'trace',
  66.      `'Trace-fast', `'continue', and `'Continue-fast'.
  67.  - User Option: edebug-trace
  68.      Default `nil'.  Non-`nil' if edebug should show a trace of
  69.      function entry and exit.  Tracing output is displayed in a buffer
  70.      named `*edebug-trace*', one function entry or exit per line,
  71.      indented by the recursion level.  You can customize by replacing
  72.      functions `edebug-print-trace-entry' and `edebug-print-trace-exit'.
  73. File: edebug,  Node: Todo List,  Prev: Options,  Up: Top
  74. Todo List
  75. =========
  76.    Send me your suggestions and priorities.
  77.    If you are interested in running edebug on functions in edebug.el, I
  78. find it easiest to first copy edebug.el into another file, say
  79. fdebug.el, and replace all strings "edebug" with "fdebug", then
  80. evaluate the fdebug buffer and run edebug on functions in fdebug.el.
  81.    * Bug: Occasionally, your elisp buffer will remain read-only after
  82.      quitting.  This is mostly an annoyance, but certainly should be
  83.      fixed.     *Let me know if you can see it - I don't see it any
  84.      more. *
  85.    * Bug: I've noticed that the point of some buffers was reset to the
  86.      point of some other buffer, but I haven't been able to repeat it
  87.      so perhaps it is fixed.
  88.    * Bug: "(" in the first column of doc strings messes up
  89.      `eval-current-buffer', and perhaps others.
  90.    * Bug: Some legal token streams are still not processed correctly by
  91.      `edebug-defun'.  For now, be sure there is a space before `'' and
  92.      don't use `""' inside strings.
  93.    * There are no other known bugs, so if you find any, please let me
  94.      know.  There is nothing worse than a buggy debugger!
  95.    * Let me know if you find any side effects that could or should be
  96.      avoided.  Also *note Side Effects::..
  97.    * Figure out how `max-lisp-eval-depth' and `max-specpdl-size' should
  98.      be set.
  99.    * Remember the window configuration inside debugger between edebug
  100.      calls and remember original configuration on the first call to
  101.      edebug after an interactive command at a lower level.
  102.    * Make edebug work with selective display - dont stop in hidden
  103.      lines.
  104.    * Handle top-level expressions (i.e. outside of defs).  Store
  105.      offsets in buffer-local variable?
  106.    * Debug just one or selected subexpressions of a defun - the rest is
  107.      evalled normally.
  108.    * Should `overlay-arrow-position' and `-string' be buffer local?
  109.    * Explicit calls to edebug in user code?
  110.    * Use copy of `current-local-map' instead of `emacs-lisp-mode-map'
  111.      (but only copy the first time after lower level command - to save
  112.      time).
  113.    * Better integration with standard debug.
  114.    * Use `inhibit-quit' while edebugging?
  115.    * Crawl mode would `sit-for' 0 or 1 in the outside window
  116.      configuration   between each edebug step.    Maybe it should be a
  117.      separate option that applies to trace as well.
  118.    * Customizable `sit-for' time.  Less than a second would be nice.
  119.    * Counting conditions - stop after n iterations.  You can do it
  120.      manually now with conditional breakpoints.
  121.    * minibuffer trace - show the current source line in the minibuffer
  122.      instead of moving point to the expression.
  123.    * Performance monitoring - summarize trace data.
  124.    * Speed up edebug-defun and edebugging - always.
  125.    * Preserve breakpoints between edebug-defun compilations?
  126.    * Backquote could be handled better, but with difficulty.
  127.    * Step into code not previously evaluated with `edebug-defun'.
  128.      Restore to no edebug version after having entered.  Partially
  129.      implemented with `i' command.
  130.    * Optionally replace expressions with results in a separate buffer
  131.      from the source code.  This idea is based on discussions with Carl
  132.      Witty regarding his stepper debugger.  Also, unparse code into its
  133.      own buffer if source code is not available, or if user wishes to
  134.      use replace-with-results mode.
  135.    * Preserve previous bindings of local variables, and allow user to
  136.      jump back to previous frames, particularly binding frames (i.e.
  137.      `let', `condition-case', function and macro calls) to view values
  138.      at that frame.  What about buffer local variables?  This is very
  139.      complex, and it would be better to have access to the Lisp stack.
  140.    * Variables display, like the evaluation list but automatically
  141.      display all local variable values.
  142. File: edebug,  Node: Index,  Prev: Top,  Up: Top
  143. Index
  144. *****
  145. * Menu:
  146. * &optional:                            Macro Calls.
  147. * &or:                                  Macro Calls.
  148. * &rest:                                Macro Calls.
  149. * *edebug* buffer:                      Evaluation.
  150. * *edebug-trace*:                       Options.
  151. * .emacs:                               Installation.
  152. * ?:                                    Using Edebug.
  153. * a:                                    Using Edebug.
  154. * abort-recursive-edit:                 Using Edebug.
  155. * anonymous lambda expressions:         Using Edebug.
  156. * autoloading edebug:                   Installation.
  157. * b:                                    Breakpoints.
  158. * B:                                    Breakpoints.
  159. * backquote:                            Macro Calls.
  160. * backtracking:                         Macro Calls.
  161. * blink current buffer:                 Views.
  162. * breakpoints:                          Breakpoints.
  163. * buffer point:                         Todo List.
  164. * c:                                    Edebug Modes.
  165. * C:                                    Edebug Modes.
  166. * C-cC-d:                               Evaluation.
  167. * C-cC-u:                               Evaluation.
  168. * C-cC-w:                               Evaluation.
  169. * C-xC-e:                               Evaluation.
  170. * C-xC-e:                               Evaluation.
  171. * C-xx:                                 Using Edebug.
  172. * calling edebug recursively:           Using Edebug.
  173. * clearing breakpoints:                 Breakpoints.
  174. * command-history:                      Side Effects.
  175. * conditional breakpoints:              Breakpoints.
  176. * continue fast mode:                   Edebug Modes.
  177. * continue mode:                        Edebug Modes.
  178. * counting conditions:                  Todo List.
  179. * current buffer point and mark:        Outside Window Configuration.
  180. * cursor-in-echo-area:                  Outside Window Configuration.
  181. * d:                                    Miscellaneous.
  182. * debug-on-error:                       Using Edebug.
  183. * debug-on-quit:                        Using Edebug.
  184. * debugger:                             Using Edebug.
  185. * debugging edebug:                     Todo List.
  186. * def-edebug-form-spec:                 Macro Calls.
  187. * defmacro:                             Using Edebug.
  188. * defun:                                Using Edebug.
  189. * displayed buffer points:              Outside Window Configuration.
  190. * dotted pair notation:                 Macro Calls.
  191. * E:                                    Evaluation.
  192. * e:                                    Evaluation.
  193. * edebug:                               Using Edebug.
  194. * edebug buffer:                        Using Edebug.
  195. * edebug display update:                Outside Window Configuration.
  196. * edebug initialization:                Installation.
  197. * edebug installation:                  Installation.
  198. * edebug modes:                         Edebug Modes.
  199. * edebug recursive edit:                Using Edebug.
  200. * edebug-all-defuns:                    Evaluating defuns.
  201. * edebug-all-defuns:                    Evaluating defuns.
  202. * edebug-all-defuns:                    Options.
  203. * edebug-backtrace:                     Miscellaneous.
  204. * edebug-bounce-point:                  Views.
  205. * edebug-continue:                      Edebug Modes.
  206. * edebug-Continue-fast:                 Edebug Modes.
  207. * edebug-defun:                         Using Edebug.
  208. * edebug-delete-eval-item:              Evaluation.
  209. * edebug-enter:                         Using Edebug.
  210. * edebug-eval-expression:               Evaluation.
  211. * edebug-eval-last-sexp:                Evaluation.
  212. * edebug-eval-last-sexp:                Evaluation.
  213. * edebug-eval-macro-args:               Macro Calls.
  214. * edebug-eval-macro-args:               Options.
  215. * edebug-eval-print-last-sexp:          Evaluation.
  216. * edebug-form-spec:                     Macro Calls.
  217. * edebug-forward-sexp:                  Miscellaneous.
  218. * edebug-global-prefix:                 Edebug Modes.
  219. * edebug-go:                            Edebug Modes.
  220. * edebug-Go-nonstop:                    Edebug Modes.
  221. * edebug-goto-here:                     Miscellaneous.
  222. * edebug-help:                          Using Edebug.
  223. * edebug-initial-mode:                  Edebug Modes.
  224. * edebug-initial-mode:                  Options.
  225. * edebug-mode:                          Using Edebug.
  226. * edebug-next-breakpoint:               Breakpoints.
  227. * edebug-previous-result:               Using Edebug.
  228. * edebug-print-trace-entry:             Options.
  229. * edebug-print-trace-exit:              Options.
  230. * edebug-save-displayed-buffer-points:  Outside Window Configuration.
  231. * edebug-save-displayed-buffer-points:  Options.
  232. * edebug-save-point:                    Options.
  233. * edebug-save-windows:                  Options.
  234. * edebug-save-windows:                  Outside Window Configuration.
  235. * edebug-set-breakpoint:                Breakpoints.
  236. * edebug-set-conditional-breakpoint:    Breakpoints.
  237. * edebug-step-in:                       Miscellaneous.
  238. * edebug-step-out:                      Miscellaneous.
  239. * edebug-step-through:                  Edebug Modes.
  240. * edebug-stop:                          Edebug Modes.
  241. * edebug-stop-before-symbols:           Options.
  242. * edebug-stop-before-symbols:           Using Edebug.
  243. * edebug-toggle-save-windows:           Views.
  244. * edebug-trace:                         Options.
  245. * edebug-trace:                         Edebug Modes.
  246. * edebug-Trace-fast:                    Edebug Modes.
  247. * edebug-unset-breakpoint:              Breakpoints.
  248. * edebug-update-eval-list:              Evaluation.
  249. * edebug-view-outside:                  Views.
  250. * edebug-visit-eval-list:               Evaluation.
  251. * edebug-where:                         Views.
  252. * edebug-where:                         Evaluation.
  253. * edebug.el:                            Installation.
  254. * emacs lisp stack frames:              Just Checking.
  255. * emacs screen display update:          Outside Window Configuration.
  256. * emacs-lisp-mode:                      Using Edebug.
  257. * embedded defun and defmacro:          Using Edebug.
  258. * entering functions:                   Miscellaneous.
  259. * epoch screens:                        Outside Window Configuration.
  260. * error or quit:                        Outside Window Configuration.
  261. * eval-current-buffer:                  Using Edebug.
  262. * eval-current-buffer:                  Todo List.
  263. * eval-current-buffer:                  Evaluating defuns.
  264. * eval-defun:                           Using Edebug.
  265. * eval-defun:                           Evaluating defuns.
  266. * eval-expression:                      Evaluation.
  267. * eval-last-sexp:                       Evaluating defuns.
  268. * eval-print-last-sexp:                 Evaluating defuns.
  269. * eval-region:                          Evaluating defuns.
  270. * evaluate in outside context:          Evaluation.
  271. * evaluation:                           Evaluation.
  272. * evaluation defuns:                    Evaluating defuns.
  273. * evaluation list group:                Evaluation.
  274. * evaluation list window:               Evaluation.
  275. * exiting functions:                    Miscellaneous.
  276. * f:                                    Miscellaneous.
  277. * function call:                        Using Edebug.
  278. * function cell:                        Using Edebug.
  279. * function symbol:                      Macro Calls.
  280. * G:                                    Edebug Modes.
  281. * g:                                    Edebug Modes.
  282. * go mode:                              Edebug Modes.
  283. * go nonstop mode:                      Edebug Modes.
  284. * h:                                    Miscellaneous.
  285. * i:                                    Miscellaneous.
  286. * ignore breakpoints:                   Edebug Modes.
  287. * in edebug:                            Using Edebug.
  288. * inhibit-quit:                         Todo List.
  289. * input pending:                        Edebug Modes.
  290. * inside context:                       The Outside Context.
  291. * interactive expression argument:      Edebug Modes.
  292. * interactive forms:                    Using Edebug.
  293. * interrupting execution:               Edebug Modes.
  294. * keyboard macros:                      Edebug Modes.
  295. * keyboard macros:                      Just Checking.
  296. * lambda expression:                    Using Edebug.
  297. * lambda expression:                    Macro Calls.
  298. * last-command:                         Recursive Edit.
  299. * last-command-char:                    Recursive Edit.
  300. * last-input-char:                      Recursive Edit.
  301. * LFD:                                  Evaluation.
  302. * lisp stack:                           Side Effects.
  303. * lisp-interaction-mode:                Evaluation.
  304. * load-library:                         Using Edebug.
  305. * load-path:                            Installation.
  306. * loading:                              Evaluating defuns.
  307. * local keymap of edebug buffer:        Recursive Edit.
  308. * local variables:                      Todo List.
  309. * macro call argument types:            Macro Calls.
  310. * macro calls:                          Macro Calls.
  311. * match data of current buffer:         Recursive Edit.
  312. * max-lisp-eval-depth:                  Just Checking.
  313. * max-lisp-eval-depth:                  Side Effects.
  314. * max-lisp-eval-depth:                  Todo List.
  315. * max-specpdl-size:                     Todo List.
  316. * max-specpdl-size:                     Side Effects.
  317. * max-specpdl-size:                     Just Checking.
  318. * minibuffer:                           Todo List.
  319. * move to stop point:                   Views.
  320. * moving overlay arrow:                 Using Edebug.
  321. * moving point:                         Using Edebug.
  322. * moving window start:                  Using Edebug.
  323. * narrow-to-region:                     Evaluating defuns.
  324. * o:                                    Miscellaneous.
  325. * options:                              Options.
  326. * outside context:                      The Outside Context.
  327. * outside context for evaluation:       Evaluation.
  328. * outside window configuration:         Views.
  329. * outside window configuration:         Outside Window Configuration.
  330. * overlay-arrow-position:               Outside Window Configuration.
  331. * overlay-arrow-string:                 Outside Window Configuration.
  332. * p:                                    Views.
  333. * pause:                                Edebug Modes.
  334. * performance monitoring:               Todo List.
  335. * point in edebug buffer:               Outside Window Configuration.
  336. * preserve breakpoints:                 Todo List.
  337. * q:                                    Using Edebug.
  338. * read sexp:                            Todo List.
  339. * read-only:                            Using Edebug.
  340. * read-only bug:                        Todo List.
  341. * read-only edebug buffer:              Recursive Edit.
  342. * reading input:                        Edebug Modes.
  343. * recursion depth:                      Side Effects.
  344. * recursive-edit:                       Recursive Edit.
  345. * replace with results:                 Todo List.
  346. * S:                                    Edebug Modes.
  347. * save-excursion:                       Outside Window Configuration.
  348. * saving and restoring:                 Just Checking.
  349. * selective display:                    Todo List.
  350. * side effects:                         Side Effects.
  351. * side effects:                         Todo List.
  352. * sit-for:                              Todo List.
  353. * sit-for:                              Outside Window Configuration.
  354. * SPC:                                  Edebug Modes.
  355. * special forms:                        Using Edebug.
  356. * standard-input:                       Recursive Edit.
  357. * standard-output:                      Recursive Edit.
  358. * step mode:                            Edebug Modes.
  359. * stop execution:                       Edebug Modes.
  360. * stop points:                          Using Edebug.
  361. * symbols:                              Using Edebug.
  362. * syntax error:                         Using Edebug.
  363. * syntax error:                         Macro Calls.
  364. * t:                                    Edebug Modes.
  365. * T:                                    Edebug Modes.
  366. * temporary breakpoints:                Breakpoints.
  367. * text changes:                         Side Effects.
  368. * this-command:                         Recursive Edit.
  369. * this-command-keys:                    Side Effects.
  370. * this-command-keys:                    Recursive Edit.
  371. * top-level:                            Using Edebug.
  372. * top-level expressions:                Todo List.
  373. * trace fast mode:                      Edebug Modes.
  374. * trace mode:                           Edebug Modes.
  375. * tracing function entry and exit:      Options.
  376. * u:                                    Breakpoints.
  377. * unread-command-char:                  Side Effects.
  378. * unread-command-char:                  Recursive Edit.
  379. * using edebug:                         Using Edebug.
  380. * v:                                    Views.
  381. * variables display:                    Todo List.
  382. * views:                                Views.
  383. * W:                                    Views.
  384. * w:                                    Views.
  385. * window configuration:                 Outside Window Configuration.
  386. * window start of edebug buffer:        Outside Window Configuration.
  387. * x:                                    Breakpoints.
  388. * x:                                    Using Edebug.
  389. * `:                                    Macro Calls.
  390.